home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
The Arsenal Files 4
/
The Arsenal Files 4 (Arsenal Computer).ISO
/
casm
/
au116-as.exe
/
AU.HPP
< prev
next >
Wrap
C/C++ Source or Header
|
1994-12-19
|
17KB
|
711 lines
/*********************************************************************/
/* Standard Include Files */
#include <dos.h>
#include <dir.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <alloc.h>
#include <bios.h>
#include <io.h>
#include <sys\stat.h>
#include <conio.h>
#include <ctype.h>
#include <fcntl.h>
#include <stdarg.h>
#include <new.h>
#include <process.h>
/**********************************************************************/
extern char *methods[];
extern char *versions[];
extern char *legal_values[];
/**********************************************************************/
#define VERSION "@?2AU@?C v1.16.10 (Beta) * Universal Archive Utilities * " __DATE__ " * (Public Domain)@?H\n"
/*********************************************************************/
/* Archive types */
/*****************/
enum ARC_TYPE
{
NONARC, // 0
ARC, // 1
ARC7, // 2
ARJ, // 3
DWC, // 4
HA, // 5
HAP, // 6
HPK, // 7
HYP, // 8
LBR, // 9
LZE, // 10
LZH, // 11
LZS, // 12
MD, // 13
PAK, // 14
RAR, // 15
SQZ, // 16
UC2, // 17
ZIP, // 18
ZOO, // 19
GIF87, // 20
GIF89, // 21
MAX_TYPES
};
/*********************************************************************/
/* Support defines */
/*******************/
/* define as FALSE the ones you do not want to support, recompile */
#define SUPPORT_ARC TRUE
#define SUPPORT_ARJ TRUE
#define SUPPORT_DWC TRUE
#define SUPPORT_HA TRUE
#define SUPPORT_HAP TRUE
#define SUPPORT_HPK TRUE
#define SUPPORT_HYP TRUE
#define SUPPORT_LBR TRUE
#define SUPPORT_LZE TRUE
#define SUPPORT_LZH TRUE
#define SUPPORT_LZS TRUE
#define SUPPORT_MD TRUE
#define SUPPORT_PAK TRUE
#define SUPPORT_RAR TRUE
#define SUPPORT_SQZ TRUE
#define SUPPORT_UC2 TRUE
#define SUPPORT_ZIP TRUE
#define SUPPORT_ZOO TRUE
#define SUPPORT_GIF TRUE
#define SUPPORT_SELF TRUE
/*********************************************************************/
/* Defines used in most of the utilities */
/*****************************************/
enum BOOLEAN {FALSE = 0, TRUE = 1};
enum STATUS {SUCCESS = 0, FAILURE = -1};
typedef unsigned char BYTE;
#define FLENGTH 80 /* Limit on dir+file length */
#define CLENGTH 127 /* Limit of a command to execute */
#define FILE_PREF 9 /* File prefix size */
#define FILE_EXT 4 /* File extension size */
#define FILE_SIZE 13 /* File Size */
#define DESC_SIZE 150 /* Max len of description */
#define ENV_SIZE 80 /* Max environment variable size */
enum CFG_VAL
{
CFG_NO_VAL = 0,
OFF = 0x0001,
ON = 0x0002,
ALWAYS = 0x0004,
LAST = 0x0008,
FIRST = 0x0010,
BENCH = 0x0020,
ONLY = 0x0040,
SKIP = 0x0080
};
#define OPUS 1
#define RBBS 2
#define GT 3
#define MAX_FLISTS 10
#define READ 0
#define WRITE 1
#define READ_WRITE 2
#define APPEND 3
#define TEMP_DIR "AU94"
#define NOTHING "Nothing to Do!\n"
#define PARAM_HEADING "@?7Command line parameters:\n" "========================\n@?H"
#define EVER ;;
#define MAX_ERRORS 10 /* Maximum number of diff errors */
#define CANT_EXECUTE 99
/*********************************************************************/
#define IMAGE_MEMORY 90000L /* Amount of memory core takes up */
/*********************************************************************/
/* Structures used in most of the utilities */
/********************************************/
//typedef struct AU AU;
class AU;
class LIST
{
public:
char *data;
LIST *next;
LIST()
{
data = NULL;
next = NULL;
}
};
class LISTPTR
{
public:
LIST *head;
LIST *tail;
void reset()
{
head = tail = NULL;
}
LISTPTR()
{
reset();
}
~LISTPTR()
{
destroy();
}
void add(char *);
void destroy();
};
typedef struct
{
int year;
unsigned char month;
unsigned char day;
} DATE;
typedef struct
{
char name[120]; /* Long for names on other systems */
char path[120];
long packed_size;
long unpacked_size;
long crc;
long attrib; /* file attributes */
unsigned char method; /* Archive Method for individual file, ie Distill, Implode, etc */
DATE date;
unsigned char hour;
unsigned char min;
unsigned char sec;
BYTE encrypted; /* Password encrypted TRUE/FALSE */
} ARC_RECORD;
class HANDLE
{
private:
int fh; /* File Handle */
int readBufferSize; /* Size of malloced buffer */
BYTE *buffer; /* Buffer */
int bufferPointer; /* Current position */
int bufferEnd; /* End position */
long bufferFilePos; /* file Byte # for start of buffer */
public:
void reset()
{
bufferPointer = 0;
bufferEnd = 0;
}
HANDLE (int size = 512)
{
readBufferSize = size;
buffer = new BYTE[size];
reset();
fh = -1;
}
// HANDLE ()
// {
// HANDLE(512);
// }
~HANDLE()
{
close();
delete [] buffer;
}
BOOLEAN is_open()
{
if (fh != -1)
return TRUE;
else
return FALSE;
}
void get_time(struct ftime *ftime_hold)
{
getftime(fh, ftime_hold);
}
void set_time(struct ftime *ftime_hold)
{
setftime(fh, ftime_hold);
}
int read_raw(void *buffer, unsigned int size)
{
reset();
return ::read(fh, buffer, size);
}
int write_raw(void *buffer, unsigned int size)
{
reset();
return ::write(fh, buffer, size);
}
int seek_raw(long pos, int from)
{
reset();
return lseek(fh, pos, from);
}
int create(char *file_name, int attrib)
{
return fh = ::creat(file_name, attrib);
}
long file_length()
{
return ::filelength(fh);
}
STATUS open(AU *, char *, int access = O_RDONLY | O_BINARY);
void close();
long seek(long, int);
int read_char();
int read_raw_line(char *);
int read_line(AU *, char *);
int read_word(char *); /* Text word */
long read_long();
int read_int();
int read_string(char *); /* Read null terminated string */
int read(char *, int);
void write_text(char *);
};
class CFG_HANDLE : public HANDLE
{
private:
HANDLE handle;
char file_name[FLENGTH];
int line_number;
public:
CFG_HANDLE() : handle(4096)
{
}
~CFG_HANDLE()
{
}
STATUS open(AU *, char *);
void close();
int read_line(AU *, char *);
void invalid_option(AU *au, char *);
void invalid(AU *, char *);
};
class ARC_HANDLE : public HANDLE
{
private:
HANDLE handle;
BYTE isFirst;
long pos;
long trailer_pos; /* Internal information needed */
int rec_number;
int hold_n; /* DWC/LBR specific variable to hold number of files */
void set_trailer_pos(AU *au);
long find_last_non_zero();
BOOLEAN search_arj(char *, int, long, long, char *);
BOOLEAN search_ha(int, char *);
void fill_date(ARC_RECORD *);
void fill_time(ARC_RECORD *);
int get_record_arc7(ARC_RECORD *record, char *name);
int get_record_arj(ARC_RECORD *record, char *name);
int get_record_dwc(ARC_RECORD *record, char *name);
int get_record_ha(ARC_RECORD *record, char *name);
int get_record_hap(ARC_RECORD *record, char *name);
int get_record_hpk(ARC_RECORD *record, char *name);
int get_record_hyp(ARC_RECORD *record, char *name);
int get_record_lbr(ARC_RECORD *record, char *name);
int get_record_lzh(ARC_RECORD *record, char *name);
int get_record_md(ARC_RECORD *record, char *name);
int get_record_pak(ARC_RECORD *record, char *name);
int get_record_rar(ARC_RECORD *record, char *name);
int get_record_sqz(ARC_RECORD *record, char *name);
int get_record_zip(ARC_RECORD *record, char *name);
int get_record_zoo(ARC_RECORD *record, char *name);
public:
ARC_TYPE type;
BYTE is_self;
int version; /* Arc version, determined as it proceed */
ARC_HANDLE () : handle(64)
{
}
~ARC_HANDLE()
{
}
STATUS init(AU *, char *file_name);
void deinit(AU *);
STATUS get_format(AU *, char *);
int get_record(AU *, ARC_RECORD *);
BYTE archive_is_optimal(AU *, char *);
};
#define MAX_LOGS 5
class LOG
{
private:
char *file_name[MAX_LOGS];
HANDLE *handle[MAX_LOGS];
int num_handles;
HANDLE *find(char *log_file);
HANDLE *add(AU *au, char *log_file);
public:
void write(AU *au, char *log_file, char *string);
LOG();
~LOG();
};
#define HEADER_RED 0 /* Redirection */
#define HEADER_AT 1 /* @ file */
#define HEADER_FILE 2 /* File */
typedef struct
{
char *name;
char extension[4];
BYTE strict_ext;
BYTE unarc_partials;
BYTE crc;
char *unarc;
char *arc;
char *del;
char *view;
char *test;
char *header;
char *unarc_path;
char *unarc_no_path;
char *arc_path;
char *arc_no_path;
char *yes_queries;
char *overwrite;
char header_method;
int memoryNeeded; /* Memory in K needed to run */
BYTE overwrite_int_check; /* Use internal overwrite check scheme */
BYTE break_err; /* User aborts errorlevel */
BYTE whatis_err;
BYTE whatis_color;
} PACKAGE;
class AU
{
public:
long memStart; // Starting amount of memory left
char *curVal;
char curOpt[30];
int sub_dirs; // Process sub dirs
BYTE current_color; // Current Color
BOOLEAN debug; // debug mode
BOOLEAN dirs_only; // Process directories only
BOOLEAN simulate; // Simulation mode
BOOLEAN show_execute; // Show executed commands
BOOLEAN no_extra; // No extraneous printing
BOOLEAN no_disp_dirs; // If true, directorys are not printed
BOOLEAN quick_test; // do quicktest TRUE/FALSE
BOOLEAN allow_rename; // Allow rename of the archive
BOOLEAN colorized; // Colorized printouts
CFG_VAL smart; // Smart Mode
CFG_VAL pause; // Pause On/Off
CFG_VAL date_retain; // first or last date
CFG_VAL self_extracts; // Self extractors
CFG_VAL unarc_paths; // Unarc into archive paths
CFG_VAL retest; // Retest suspicious archives
CFG_VAL recurse; // Recursive unarcs
CFG_VAL delete_behind; // Delete archive after unarcing
CFG_VAL warn_non_dos; // Warn if non dos files names inside archive
CFG_VAL warn_path; // Warn if path inside archive
CFG_VAL warn_hidden; // Warn if hidden/system inside archive
CFG_VAL warn_existing; // Warn if files already exist
CFG_VAL answer_y; // Automated process
CFG_VAL scan_self; // Scan self extracts
char cfg_file[FLENGTH]; // Configuration file to use
int cfg_line; // line number in cfg
char *def_file_spec; // Environment variable containing file spec
char cur_directory[FLENGTH];
char last_dir[FLENGTH]; // When changes, display dir
char source_directory[FLENGTH];
char old_source_dir[FLENGTH];
char dest_directory[FLENGTH];
char old_dest_dir[FLENGTH];
char *argv0; // argv[0], used for the .exe path
char output[FLENGTH];
char partial[FLENGTH];
char look_through[FILE_SIZE];
char will_process[1000][FILE_SIZE];
LISTPTR dont_touch;
int wp_count;
int number_processed;
int number_changed;
LISTPTR process_list;
char flist[MAX_FLISTS][FLENGTH];
char append_flist[MAX_FLISTS];
char force_mode;
char description[DESC_SIZE];
char desc_file[FILE_SIZE];
int flist_pos;
LOG log;
char flist_log[FLENGTH];
char problem_log[FLENGTH];
char action_log[FLENGTH];
PACKAGE package[MAX_TYPES];
LISTPTR bad_list[MAX_ERRORS];
int bad_count[MAX_ERRORS];
char rename_to[FLENGTH]; // What to rename it to if test fails
int num_processed[20]; // Used by unarc
char y_file[80];
char scanner[FLENGTH];
int SC_NoVirus_EL; // No virus errorlevel
int SC_Virus_EL; // Virus errorlevel
int scannerMemNeeded; // Memory needed for the scanner
char **env; // Points to local environment
char env_var[ENV_SIZE]; // Environment variable for result
char env_cont[CLENGTH]; // Value to assign it to
void *info; // Latch for local structure
AU(char *[], char *[], long); // Constructor
};
extern AU *glob_au;
/*********************************************************************/
/* Function Prototypes */
/***********************/
/* Main's */
int main_add(AU *au, int, char *[]);
int main_compare(AU *, int, char *[]);
int main_convert(AU *, int, char *[]);
int main_delete(AU *, int, char *[]);
int main_dir(AU *, int, char *[]);
int main_dupes(AU *, int, char *[]);
int main_find(AU *, int, char *[]);
int main_fixcr(AU *, int, char *[]);
int main_header(AU *, int, char *[]);
int main_orphan(AU *, int, char *[]);
int main_patch(AU *, int, char *[]);
int main_redate(AU *, int, char *[]);
int main_scan(AU *, int, char *[]);
int main_size(AU *, int, char *[]);
int main_strip(AU *, int, char *[]);
int main_sweep(AU *, int, char *[]);
int main_test(AU *au, int, char *[]);
int main_unarc(AU *, int, char *[]);
int main_version(AU *, int, char *[]);
int main_view(AU *, int, char *[]);
int main_whatis(AU *, int, char *[]);
int unarc(AU *, char *, char *, LISTPTR *, int, BYTE);
int scan_one_file(AU *au, char *);
int test(AU *, char *);
int redate_file(AU *, char *);
void ReadGlobalCFGInfo(AU *, char *, char *, void (*)(AU *, CFG_HANDLE *));
int control_break(void);
void set_ctrl_brk(void);
/* Util.LIB *********************************************/
typedef enum
{
PARSE_SINGLE_OPTION,
PARSE_PARAM_OPTION,
PARSE_FILESPEC,
PARSE_POST_CHECK
} PARSE_TYPE;
#define PARSE_PARAMS AU *, char, char *, PARSE_TYPE
void generic_parse_comm_line(AU *, int, char *[], BYTE (*)(PARSE_PARAMS));
CFG_VAL get_value(AU *, unsigned);
int process_files(AU *, int (*)(AU *, char *)),
count_process_files(AU *),
ask_continue(void),
display_bad_arcs(AU *au),
is_dos_name(char *),
rename_strict(AU *, PACKAGE *, char *, char *),
rename_strict_back(char *, char *),
clean_paths(AU *, LISTPTR *),
get_next_file_name(AU *, HANDLE *, char *, int *);
unsigned short crc16(AU *, char *);
unsigned long crc32(AU *, char *);
unsigned long crc32_string(char *, unsigned int);
long days_diff(DATE *, DATE *),
check_threshold(AU *, int, BYTE);
void check_for_key(void),
press_any_key(AU *au),
split_string(char *, char *),
append_backslash(char *),
fix_flist(AU *, char *, char *),
add_to_flist(AU *, char *, int),
add_to_bad_list(AU *, char *, char *, BYTE errorlevel=0, int level=0),
split_file(char *, char *, char *),
build_fname(char *, char *, char *),
fill_list_from_BBS(AU *, char *),
fix_path(char *),
get_ns(AU *, char *, ARC_HANDLE *, LISTPTR *, LISTPTR *, LISTPTR *,
LISTPTR *, LISTPTR *, LISTPTR *),
substitute_macros(char *, char *, char *, char *, char *, char *),
date_add(DATE *, DATE *, long),
get_full_file_name(AU *, char *, char *),
au_invalid_option(AU *, char *, char),
au_syntax_message(AU *, char *),
au_opt_filespec_message(AU *),
au_filespec_message(AU *),
au_param_heading(AU *),
au_standard_opt_header(AU *, char *, char *),
subst_environ(AU *, char *),
act_log_printf(AU *au, char *format, ...),
fdate_to_date(DATE *, struct ffblk *),
version_print(AU *, int, int, BOOLEAN);
char ok_to_process(AU *, char *),
wildcard_compare(AU *, char *, char *),
fill_file_array(char *);
char *left_pad(char *, int),
*right_pad(char *, int),
*ltrim(char *),
*rtrim(char *),
*fit_mask(char *,char *),
*date_to_string(DATE *),
*hms_to_string(int, int, int),
*percent_string(long, long),
*safe_string_copy(char *, char *, int, BYTE);
void *au_malloc(AU *, int);
void *au_calloc(AU *, int, int);
char *string_save(AU *, char *);
BYTE archive_is_old(int);
BYTE file_is_not_optimal(int);
BYTE file_is_stored(int);
BYTE find_ext(AU *, char *);
BOOLEAN dir_exists(AU *, char *);
BOOLEAN is_binary_file_char(int);
STATUS cd(AU *, char *, char *x=NULL, BYTE dispError=TRUE);
STATUS process_at_file(AU *, LISTPTR *, char *);
/* Ibmdos.LIB ***********************************************/
char my_getch(),
my_toupper(char);
char *my_itoa(int),
*my_ltoa(long),
*keyboard_buffer(char *);
HANDLE au_open(AU *, char *, int access = O_RDONLY | O_BINARY);
int my_atoi(char *),
execute(AU *, char *, char *, char *, int),
execute_raw(AU *, char *),
alter_env(AU *, char *, char *[]);
BYTE is_stdout(void);
BYTE is_next_control_s(void);
void string_replace(char *, char *, char *);
void au_printf(AU *, char *, ...);
void au_printf_c(AU *, char, char *, ...);
void au_printf_error(AU *, char *, ...);
void get_file_time(AU *, char *, struct ftime *);
void set_file_time(AU *, char *, struct ftime *);
//long my_fpos(HANDLE);